var Event = require('bcore/event');
var $ = require('jquery');
var _ = require('lodash');

/**
 * 天地图卫星地图组件
 */
module.exports = Event.extend(function Base(container, config) {
  this.config = {
    theme: {},
    tdtKey: '您的密钥',
    center: {
      lng: 116.397428,
      lat: 39.90923
    },
    zoom: 12,
    minZoom: 1,
    maxZoom: 18,
    enableZoom: true,
    enableDrag: true,
    showAnnotation: true,
    markerStyle: {
      showMarker: true,
      markerSize: 30,
      markerColor: '#FF0000'
    },
    markerFlyToZoom: {
      clusterZoom: 16,
      pointZoom: 16
    },
    infoWindowStyle: {
      // 聚合类型信息窗口样式
      cluster: {
        minWidth: '80px',
        maxWidth: '120px',
        fontSize: '12px',
        color: '#333',
        titleFontSize: '13px',
        titleColor: '#000',
        titleMarginBottom: '4px'
      },
      // 点类型信息窗口样式
      point: {
        padding: '1px',
        minWidth: '200px',
        fontSize: '14px',
        color: '#333',
        titleFontSize: '16px',
        titleColor: '#000',
        titleMarginBottom: '8px',
        locationColor: '#666',
        locationMarginBottom: '6px',
        contentMarginBottom: '6px',
        imageMarginTop: '8px',
        imageBorderColor: '#ddd',
        imageBorderWidth: '2px',
        imageBorderRadius: '4px',
        imageTipFontSize: '12px',
        imageTipColor: '#666'
      }
    }
  };
  
  this.container = $(container);           // 容器
  this.apis = config.apis;                 // hook一定要有
  this._data = null;                       // 数据
  this.map = null;                         // 地图实例
  this.markers = [];                       // 标记点数组
  this.polygons = [];                      // 多边形数组
  this.annotationLayer = null;             // 地名标注图层
  this.mapContainer = null;                // 地图容器DOM
  this.tdtLoaded = false;                  // 天地图API加载状态
  this._pointTypeHovering = false;         // 点类型标记点是否正在悬停
  this._clusterManualHover = false;        // 聚合类型标记点是否手动悬停
  this._carouselRestartTimer = null;       // 轮播重启定时器（防抖）
  
  this.init(config);
}, {
  /**
   * 公有初始化
   */
  init: function (config) {
    // 1.初始化,合并配置
    this.mergeConfig(config);
    
    // 2.创建地图容器
    this.createMapContainer();
    
    // 3.加载天地图API
    this.loadTiandituAPI();
    
    // 4.更新样式
    this.updateStyle();
  },
  
  /**
   * 创建地图容器
   */
  createMapContainer: function() {
    this.container.html('<div id="tdt-map-container" style="width:100%;height:100%;position:absolute;top:0;left:0;margin:0;padding:0;"></div>');
    this.mapContainer = this.container.find('#tdt-map-container')[0];
  },
  
  /**
   * 加载天地图API
   */
  loadTiandituAPI: function() {
    var self = this;
    
    // 检查是否已经加载
    if (window.T) {
      self.tdtLoaded = true;
      self.initMap();
      return;
    }
    
    // 动态加载天地图API脚本（使用HTTPS）
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = 'https://api.tianditu.gov.cn/api?v=4.0&tk=' + this.config.tdtKey;
    script.onload = function() {
      self.tdtLoaded = true;
      self.initMap();
    };
    script.onerror = function() {
      console.error('天地图API加载失败，请检查网络连接和密钥是否正确');
    };
    document.head.appendChild(script);
  },
  
  /**
   * 初始化地图
   */
  initMap: function() {
    if (!window.T || !this.mapContainer) {
      return;
    }
    
    var cfg = this.config;
    var self = this;
    
    // 检查密钥是否已配置
    if (!cfg.tdtKey || cfg.tdtKey === '您的密钥') {
      this.container.html('<div style="display:flex;align-items:center;justify-content:center;height:100%;color:#ff0000;font-size:14px;">请在配置面板中填入有效的天地图密钥（Key）</div>');
      console.error('请配置天地图密钥！访问 http://lbs.tianditu.gov.cn/ 注册并申请密钥');
      return;
    }
    
    // 创建地图实例
    this.map = new T.Map(this.mapContainer);
    
    // 设置地图中心点和缩放级别
    // 优先使用待设置的中心点（来自数据源），否则使用配置的默认中心点
    var initCenter = this._pendingCenter || cfg.center;
    var initZoom = this._pendingZoom !== undefined ? this._pendingZoom : cfg.zoom;
    var centerPoint = new T.LngLat(initCenter.lng, initCenter.lat);
    this.map.centerAndZoom(centerPoint, initZoom);
    console.log('[天地图组件] initMap 中设置的中心点：', initCenter.lng, initCenter.lat, '（使用', this._pendingCenter ? '数据源中心点' : '默认中心点', '）');
    
    // 清除待设置的中心点
    this._pendingCenter = null;
    this._pendingZoom = undefined;
    
    // 清除默认图层
    this.map.clearLayers();
    
    // 创建自定义图层类以支持多服务器负载均衡（全局）
    if (!window.TDTImageLayer) {
      window.TDTImageLayer = T.TileLayer.extend({
        initialize: function(url, options) {
          T.TileLayer.prototype.initialize.call(this, url, options);
          this._serverIndex = 0;
        },
        getTileUrl: function(coords) {
          var url = T.TileLayer.prototype.getTileUrl.call(this, coords);
          // 轮询选择服务器
          var serverNum = this._serverIndex % 8;
          this._serverIndex++;
          url = url.replace('t0.', 't' + serverNum + '.');
          return url;
        }
      });
    }
    
    // 创建卫星影像图层
    var imgUrl = "https://t0.tianditu.gov.cn/img_w/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=img&STYLE=default&TILEMATRIXSET=w&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=" + cfg.tdtKey;
    var lay = new window.TDTImageLayer(imgUrl, {
      minZoom: cfg.minZoom,
      maxZoom: cfg.maxZoom
    });
    this.map.addLayer(lay);
    
    // 添加地名标注图层（可选）
    this.updateAnnotationLayer();
    
    // 设置地图缩放范围
    this.map.setMinZoom(cfg.minZoom);
    this.map.setMaxZoom(cfg.maxZoom);
    
    // 设置地图控制选项
    if (!cfg.enableZoom) {
      this.map.disableScrollWheelZoom();
    } else {
      // 禁用默认滚轮缩放，使用自定义缩放（步长为1）
      this.map.disableScrollWheelZoom();
      this.enableCustomScrollZoom(1); // 步长为1
    }
    
    if (!cfg.enableDrag) {
      this.map.disableDrag();
    } else {
      this.map.enableDrag();
    }
    
    // 如果已有数据，渲染标记点
    if (this._data) {
      this.renderMarkers(this._data);
    }
    
    // 监听地图缩放事件，控制标记点显示
    var self = this;
    this.map.addEventListener('zoomend', function() {
      self.updateMarkersVisibility();
      self.updateZoomDisplay();
    });
    
    // 确保地图正确填充容器
    setTimeout(function() {
      if (self.map) {
        self.map.checkResize();
      }
    }, 200);
    
    // 添加全局样式，隐藏信息窗口的关闭按钮
    this.addInfoWindowStyles();
    
    // 添加自定义InfoWindow样式覆盖
    this.addCustomInfoWindowStyles();
    
    // 添加缩放级别显示控件
    this.addZoomDisplay();
    
    // 轮播控制状态
    this._carouselPaused = false;
  },
  
  /**
   * 应用InfoWindow样式
   */
  _applyInfoWindowStyles: function(style, infoWindowObj) {
    var self = this;
    var applyStylesImmediately = function() {
      // 查找所有InfoWindow元素
      var infoWindowElements = document.querySelectorAll('.tdt-infowindow');
      if (infoWindowElements.length > 0) {
        // 应用到所有InfoWindow元素，确保每个都能正确显示样式
        for (var i = 0; i < infoWindowElements.length; i++) {
          var infoWindowElement = infoWindowElements[i];
          
          
          // 立即应用内联样式，使用setProperty确保优先级
          var bgColor = style.backgroundColor || '#ffffff';
          var borderColor = style.borderColor || '#ddd';
          var borderWidth = style.borderWidth || '1px';
          var borderRadius = style.borderRadius || '8px';
          var boxShadow = style.boxShadow || '0 4px 20px rgba(0,0,0,0.15)';
          var padding = style.padding || '15px';
          var minWidth = style.minWidth || '250px';
          var maxWidth = style.maxWidth || '400px';
          var fontSize = style.fontSize || '14px';
          var color = style.color || '#333';
          
          // 使用setProperty确保样式优先级
          infoWindowElement.style.setProperty('background-color', bgColor, 'important');
          infoWindowElement.style.setProperty('background', bgColor, 'important');
          infoWindowElement.style.setProperty('border-color', borderColor, 'important');
          infoWindowElement.style.setProperty('border-width', borderWidth, 'important');
          infoWindowElement.style.setProperty('border-radius', borderRadius, 'important');
          infoWindowElement.style.setProperty('box-shadow', boxShadow, 'important');
          infoWindowElement.style.setProperty('padding', padding, 'important');
          infoWindowElement.style.setProperty('min-width', minWidth, 'important');
          infoWindowElement.style.setProperty('max-width', maxWidth, 'important');
          infoWindowElement.style.setProperty('font-size', fontSize, 'important');
          infoWindowElement.style.setProperty('color', color, 'important');
          
          // 应用CSS变量
          infoWindowElement.style.setProperty('--custom-bg-color', style.backgroundColor || '#ffffff');
          infoWindowElement.style.setProperty('--custom-border-color', style.borderColor || '#ddd');
          infoWindowElement.style.setProperty('--custom-border-width', style.borderWidth || '1px');
          infoWindowElement.style.setProperty('--custom-border-radius', style.borderRadius || '8px');
          infoWindowElement.style.setProperty('--custom-box-shadow', style.boxShadow || '0 4px 20px rgba(0,0,0,0.15)');
          infoWindowElement.style.setProperty('--custom-padding', style.padding || '15px');
          infoWindowElement.style.setProperty('--custom-min-width', style.minWidth || '250px');
          infoWindowElement.style.setProperty('--custom-max-width', style.maxWidth || '400px');
          infoWindowElement.style.setProperty('--custom-font-size', style.fontSize || '14px');
          infoWindowElement.style.setProperty('--custom-color', style.color || '#333');
          
          console.log('[样式应用] 标题样式配置:', {
            titleFontSize: style.titleFontSize,
            titleColor: style.titleColor,
            color: style.color,
            fontSize: style.fontSize
          });
          
          infoWindowElement.style.setProperty('--custom-title-font-size', style.titleFontSize || '16px');
          infoWindowElement.style.setProperty('--custom-title-color', style.titleColor || '#000');
          infoWindowElement.style.setProperty('--custom-title-margin-bottom', style.titleMarginBottom || '8px');
          infoWindowElement.style.setProperty('--custom-location-color', style.locationColor || '#666');
          infoWindowElement.style.setProperty('--custom-location-margin-bottom', style.locationMarginBottom || '10px');
          infoWindowElement.style.setProperty('--custom-content-margin-bottom', style.contentMarginBottom || '10px');
          infoWindowElement.style.setProperty('--custom-image-margin-top', style.imageMarginTop || '12px');
          infoWindowElement.style.setProperty('--custom-image-border-color', style.imageBorderColor || '#eee');
          infoWindowElement.style.setProperty('--custom-image-border-width', style.imageBorderWidth || '1px');
          infoWindowElement.style.setProperty('--custom-image-border-radius', style.imageBorderRadius || '6px');
          infoWindowElement.style.setProperty('--custom-image-tip-font-size', style.imageTipFontSize || '12px');
          infoWindowElement.style.setProperty('--custom-image-tip-color', style.imageTipColor || '#999');
          
          // 强制外层容器宽度自适应
          infoWindowElement.style.setProperty('width', 'fit-content', 'important');
          infoWindowElement.style.setProperty('min-width', style.minWidth || '0', 'important');
          infoWindowElement.style.setProperty('max-width', style.maxWidth || 'none', 'important');
          
          // 强制内部容器宽度自适应
          var contentWrappers = infoWindowElement.querySelectorAll('.tdt-infowindow-content, .tdt-infowindow-content-wrapper');
          for (var k = 0; k < contentWrappers.length; k++) {
            var wrapper = contentWrappers[k];
            wrapper.style.setProperty('width', 'fit-content', 'important');
            wrapper.style.setProperty('min-width', '0', 'important');
            wrapper.style.setProperty('max-width', '100%', 'important');
          }
          
          // 只对最后一个（最新打开的）InfoWindow 应用位置修复
          // 避免影响轮播的 InfoWindow
          if (i === infoWindowElements.length - 1) {
            console.log('[_applyInfoWindowStyles] 应用位置修复 - 当前宽度:', infoWindowElement.offsetWidth);
            
            // 直接修正 left 偏移量（应该是宽度的一半，实现居中）
            setTimeout(function() {
              infoWindowElement.offsetWidth; // 强制重排，确保宽度完全稳定
              var correctLeft = -Math.round(infoWindowElement.offsetWidth / 2);
              console.log('[_applyInfoWindowStyles-50ms] 修正 left:', infoWindowElement.style.left, '->', correctLeft + 'px');
              infoWindowElement.style.left = correctLeft + 'px';
            }, 50);
          }
        }
        
        return true;
      }
      return false;
    };
    
    // 立即尝试应用样式
    setTimeout(applyStylesImmediately, 0);
  },

  /**
   * 全局样式应用函数 - 确保所有信息弹窗都能正确应用样式
   */
  applyGlobalInfoWindowStyles: function() {
    // 独立InfoWindow机制下，不再需要全局样式应用
    return;
  },

  /**
   * 添加自定义InfoWindow样式覆盖
   */
  addCustomInfoWindowStyles: function() {
    // 检查是否已经添加过
    if (document.getElementById('tdt-custom-infowindow-styles')) {
      return;
    }
    
    var style = document.createElement('style');
    style.id = 'tdt-custom-infowindow-styles';
    style.innerHTML = `
      /* 覆盖天地图原生InfoWindow样式 - 可配置版本 */
      .tdt-infowindow {
        z-index: 99999 !important;
        background-color: var(--custom-bg-color, #ffffff) !important;
        background: var(--custom-bg-color, #ffffff) !important;
        border: var(--custom-border-width, 1px) solid var(--custom-border-color, #ddd) !important;
        border-radius: var(--custom-border-radius, 8px) !important;
        box-shadow: var(--custom-box-shadow, 0 4px 20px rgba(0,0,0,0.15)) !important;
        padding: var(--custom-padding, 15px) !important;
        width: fit-content !important;
        min-width: var(--custom-min-width, 0) !important;
        max-width: var(--custom-max-width, none) !important;
        font-size: var(--custom-font-size, 14px) !important;
        color: var(--custom-color, #333) !important;
        line-height: 1.5 !important;
        font-family: Arial, sans-serif !important;
        /* 强制覆盖默认样式 */
        background: var(--custom-bg-color, #ffffff) !important;
        border-style: solid !important;
        border-width: var(--custom-border-width, 1px) !important;
        border-color: var(--custom-border-color, #ddd) !important;
        /* 位置修正 - 移除强制设置，让天地图API自己处理位置 */
      }
      
      /* 增强覆盖规则，确保第一次渲染时也能正确显示 */
      .tdt-infowindow.tdt-zoom-animated {
        background-color: var(--custom-bg-color, #ffffff) !important;
        background: var(--custom-bg-color, #ffffff) !important;
        border-color: var(--custom-border-color, #ddd) !important;
        border-width: var(--custom-border-width, 1px) !important;
        border-radius: var(--custom-border-radius, 8px) !important;
        box-shadow: var(--custom-box-shadow, 0 4px 20px rgba(0,0,0,0.15)) !important;
        padding: var(--custom-padding, 15px) !important;
        width: fit-content !important;
        min-width: var(--custom-min-width, 0) !important;
        max-width: var(--custom-max-width, none) !important;
        font-size: var(--custom-font-size, 14px) !important;
        color: var(--custom-color, #333) !important;
      }
      
      /* 移除所有内部容器的背景和边框 */
      .tdt-infowindow-content,
      .tdt-infowindow-content-wrapper,
      .tdt-infowindow-content-wrapper > div {
        background-color: transparent !important;
        border: none !important;
        padding: 0 !important;
        margin: 0 !important;
        box-shadow: none !important;
        width: fit-content !important;
        min-width: 0 !important;
        max-width: none !important;
      }
      
      /* 隐藏箭头 */
      .tdt-infowindow-tip,
      .tdt-infowindow-tip-container {
        display: none !important;
      }
      
      /* 内容样式 - 可配置版本 */
      .tdt-infowindow .info-title,
      .tdt-infowindow-content .info-title,
      .info-title {
        font-size: var(--custom-title-font-size, 16px) !important;
        font-weight: bold !important;
        margin-bottom: var(--custom-title-margin-bottom, 8px) !important;
        color: var(--custom-title-color, #000) !important;
        line-height: 1.3 !important;
      }
      
      .tdt-infowindow .info-location,
      .tdt-infowindow-content .info-location,
      .info-location {
        margin-bottom: var(--custom-location-margin-bottom, 10px) !important;
        color: var(--custom-location-color, #666) !important;
        font-size: 13px !important;
      }
      
      .tdt-infowindow .info-content,
      .tdt-infowindow-content .info-content,
      .info-content {
        margin-bottom: var(--custom-content-margin-bottom, 10px) !important;
        line-height: 1.4 !important;
        color: var(--custom-color, #333) !important;
      }
      
      .tdt-infowindow .info-image,
      .tdt-infowindow-content .info-image,
      .info-image {
        margin-top: var(--custom-image-margin-top, 12px) !important;
        cursor: pointer !important;
      }
      
      .tdt-infowindow .info-image img,
      .tdt-infowindow-content .info-image img,
      .info-image img {
        width: 100% !important;
        max-width: 100% !important;
        height: auto !important;
        border: var(--custom-image-border-width, 1px) solid var(--custom-image-border-color, #eee) !important;
        border-radius: var(--custom-image-border-radius, 6px) !important;
        display: block !important;
      }
      
      .tdt-infowindow .image-tip,
      .tdt-infowindow-content .image-tip,
      .image-tip {
        text-align: center !important;
        margin-top: 6px !important;
        font-size: var(--custom-image-tip-font-size, 12px) !important;
        color: var(--custom-image-tip-color, #999) !important;
      }
    `;
    
    document.head.appendChild(style);
  },

  /**
   * 添加信息窗口样式
   */
  addInfoWindowStyles: function() {
    // 检查是否已经添加过样式
    if (document.getElementById('tdt-infowindow-style')) {
      return;
    }
    
    var style = document.createElement('style');
    style.id = 'tdt-infowindow-style';
    style.innerHTML = `
      /* 隐藏信息窗口关闭按钮 */
      .tdt-infowindow-close-button,
      .tdt-infowindow-close,
      .tdt-infowindow-top-wrap a,
      .tdt-infowindow a[title="关闭"],
      .tdt-infowindow .close {
        display: none !important;
      }
      
      /* 缩放级别显示样式 */
      #tdt-zoom-display {
        position: absolute;
        top: 10px;
        right: 10px;
        background: rgba(255, 255, 255, 0.9);
        padding: 6px 12px;
        border-radius: 4px;
        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.3);
        font-size: 14px;
        font-weight: bold;
        color: #333;
        z-index: 1000;
        pointer-events: none;
      }
    `;
    document.head.appendChild(style);
  },
  
  /**
   * 添加缩放级别显示控件
   */
  addZoomDisplay: function() {
    // 检查是否已经添加过
    if (document.getElementById('tdt-zoom-display')) {
      return;
    }
    
    var zoomDisplay = document.createElement('div');
    zoomDisplay.id = 'tdt-zoom-display';
    zoomDisplay.innerHTML = '级别: ' + (this.map ? this.map.getZoom() : this.config.zoom);
    
    // 添加到地图容器中
    this.mapContainer.appendChild(zoomDisplay);
  },
  
  /**
   * 更新缩放级别显示
   */
  updateZoomDisplay: function() {
    var zoomDisplay = document.getElementById('tdt-zoom-display');
    if (zoomDisplay && this.map) {
      zoomDisplay.innerHTML = '级别: ' + this.map.getZoom();
    }
  },
  
  /**
   * 为点类型信息窗口添加悬停事件监听
   */
  addInfoWindowHoverListenersForPoint: function(marker, customInfoWindow) {
    var self = this;
    
    // 查找自定义信息弹窗的DOM元素
    var infoWindowElements = document.querySelectorAll('div[style*="position: absolute"][style*="z-index: 1000"]');
    
    // 查找最新打开的信息窗口（通常是最后一个）
    if (infoWindowElements.length > 0) {
      var infoWindowDom = infoWindowElements[infoWindowElements.length - 1];
      
      // 防止重复添加监听器
      if (infoWindowDom._hasHoverListener) {
        return;
      }
      infoWindowDom._hasHoverListener = true;
      
      // 鼠标进入信息窗口
      infoWindowDom.addEventListener('mouseenter', function(e) {
        e.stopPropagation();
        
        // 取消关闭定时器
        if (marker._closeTimer) {
          clearTimeout(marker._closeTimer);
          marker._closeTimer = null;
        }
      });
      
      // 鼠标离开信息窗口
      infoWindowDom.addEventListener('mouseleave', function(e) {
        // 延迟关闭信息窗口
        marker._closeTimer = setTimeout(function() {
          if (customInfoWindow) {
            self.map.removeOverLay(customInfoWindow);
          }
          
          // 清除之前的轮播重启定时器（防抖）
          if (self._carouselRestartTimer) {
            clearTimeout(self._carouselRestartTimer);
          }
          
          // 延迟恢复聚合类型轮播，确保点类型窗口完全关闭后再启动
          self._carouselRestartTimer = setTimeout(function() {
            self._pointTypeHovering = false;
            self.restartClusterInfoCarousel();
            self._carouselRestartTimer = null;
          }, 200); // 额外延迟200ms
        }, 500);
      });
    }
  },
  
  /**
   * 启用自定义滚轮缩放
   * @param {number} step - 缩放步长，默认1
   */
  enableCustomScrollZoom: function(step) {
    var self = this;
    var mapContainer = this.mapContainer;
    var zoomStep = step || 1;
    
    if (!mapContainer) {
      return;
    }
    
    // 监听鼠标滚轮事件
    var wheelHandler = function(e) {
      e.preventDefault();
      e.stopPropagation();
      
      if (!self.map) {
        return;
      }
      
      var currentZoom = self.map.getZoom();
      var delta = 0;
      
      // 判断滚轮方向
      if (e.deltaY) {
        delta = e.deltaY > 0 ? -zoomStep : zoomStep;
      } else if (e.wheelDelta) {
        delta = e.wheelDelta > 0 ? zoomStep : -zoomStep;
      } else if (e.detail) {
        delta = e.detail > 0 ? -zoomStep : zoomStep;
      }
      
      var newZoom = currentZoom + delta;
      
      // 限制缩放范围
      var minZoom = self.config.minZoom || 1;
      var maxZoom = self.config.maxZoom || 18;
      
      if (newZoom < minZoom) {
        newZoom = minZoom;
      }
      if (newZoom > maxZoom) {
        newZoom = maxZoom;
      }
      
      // 设置新的缩放级别
      if (newZoom !== currentZoom) {
        self.map.setZoom(newZoom);
      }
    };
    
    // 添加滚轮事件监听
    if (mapContainer.addEventListener) {
      mapContainer.addEventListener('wheel', wheelHandler, { passive: false });
      mapContainer.addEventListener('mousewheel', wheelHandler, { passive: false });
      mapContainer.addEventListener('DOMMouseScroll', wheelHandler, { passive: false });
    } else if (mapContainer.attachEvent) {
      mapContainer.attachEvent('onmousewheel', wheelHandler);
    }
    
    // 保存事件处理器引用，以便后续清理
    this._wheelHandler = wheelHandler;
  },
  
  /**
   * 更新地名标注图层
   */
  updateAnnotationLayer: function() {
    if (!this.map || !window.T) {
      return;
    }
    
    var cfg = this.config;
    var self = this;
    
    // 创建自定义图层类（如果还没创建）
    if (!window.TDTImageLayer) {
      window.TDTImageLayer = T.TileLayer.extend({
        initialize: function(url, options) {
          T.TileLayer.prototype.initialize.call(this, url, options);
          this._serverIndex = 0;
        },
        getTileUrl: function(coords) {
          var url = T.TileLayer.prototype.getTileUrl.call(this, coords);
          var serverNum = this._serverIndex % 8;
          this._serverIndex++;
          url = url.replace('t0.', 't' + serverNum + '.');
          return url;
        }
      });
    }
    
    // 如果需要显示标注
    if (cfg.showAnnotation) {
      // 如果标注图层已存在，不需要重新添加
      if (!this.annotationLayer) {
        var annoUrl = "https://t0.tianditu.gov.cn/cia_w/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=cia&STYLE=default&TILEMATRIXSET=w&FORMAT=tiles&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&tk=" + cfg.tdtKey;
        this.annotationLayer = new window.TDTImageLayer(annoUrl, {
          minZoom: cfg.minZoom,
          maxZoom: cfg.maxZoom
        });
        this.map.addLayer(this.annotationLayer);
      }
    } else {
      // 如果不需要显示标注，移除现有的标注图层
      if (this.annotationLayer) {
        this.map.removeLayer(this.annotationLayer);
        this.annotationLayer = null;
      }
    }
  },
  
  /**
   * 根据当前缩放级别更新标记点和边界显示状态
   */
  updateMarkersVisibility: function() {
    if (!this.map) {
      return;
    }
    
    var currentZoom = this.map.getZoom();
    var visibleClusterMarkers = []; // 存储当前可见的聚合类型标记点
    
    // 根据每个标记点自己的配置来决定显示/隐藏
    for (var i = 0; i < this.markers.length; i++) {
      var marker = this.markers[i];
      var minZoom = marker._minZoomLevel !== undefined ? marker._minZoomLevel : 1;
      var maxZoom = marker._maxZoomLevel !== undefined ? marker._maxZoomLevel : 18;
      
      // 判断当前缩放级别是否在该标记点的显示范围内
      var shouldShow = currentZoom >= minZoom && currentZoom <= maxZoom;
      
      if (shouldShow) {
        marker.show();
        
        // 收集可见的聚合类型标记点
        if (marker._markerType === 1) {
          visibleClusterMarkers.push(marker);
        }
      } else {
        marker.hide();
        
        // 如果是聚合类型，关闭信息窗口
        if (marker._markerType === 1 && marker._infoWindow) {
          marker.closeInfoWindow();
        }
      }
    }
    
    // 处理聚合类型标记点的信息窗口显示
    if (visibleClusterMarkers.length > 0) {
      // 关闭所有现有的聚合类型信息窗口
      for (var j = 0; j < this.markers.length; j++) {
        var existingMarker = this.markers[j];
        if (existingMarker._markerType === 1 && existingMarker._infoWindow) {
          existingMarker.closeInfoWindow();
        }
      }
      
      // 启动轮播显示（仅在自动模式下）
      if (!this._clusterManualHover) {
        this.startClusterInfoCarousel(visibleClusterMarkers);
      }
    } else {
      // 停止轮播
      this.stopClusterInfoCarousel();
    }
    
    // 根据每个多边形自己的配置来决定显示/隐藏
    for (var i = 0; i < this.polygons.length; i++) {
      var polygon = this.polygons[i];
      var minZoom = polygon._minZoomLevel !== undefined ? polygon._minZoomLevel : 1;
      var maxZoom = polygon._maxZoomLevel !== undefined ? polygon._maxZoomLevel : 18;
      
      // 判断当前缩放级别是否在该多边形的显示范围内
      var shouldShow = currentZoom >= minZoom && currentZoom <= maxZoom;
      
      if (shouldShow) {
        polygon.show();
      } else {
        polygon.hide();
      }
    }
  },
  
  /**
   * 启动聚合类型信息窗口轮播
   * @param {Array} clusterMarkers 聚合类型标记点数组
   */
  startClusterInfoCarousel: function(clusterMarkers) {
    if (!this.map || clusterMarkers.length === 0) {
      return;
    }
    
    // 停止之前的轮播
    this.stopClusterInfoCarousel();
    
    if (clusterMarkers.length === 1) {
      // 只有一个聚合类型标记点，直接显示
      var clusterMarker = clusterMarkers[0];
      if (clusterMarker._customInfoWindow) {
        clusterMarker.openInfoWindow(clusterMarker._customInfoWindow);
        // 应用自定义样式 - 立即应用
        if (clusterMarker._customInfoWindow._applyCustomStyles) {
          clusterMarker._customInfoWindow._applyCustomStyles();
        }
      }
      return;
    }
    
    // 检查轮播是否被暂停
    if (this._carouselPaused) {
      return;
    }
    
    // 多个聚合类型标记点，启动轮播
    this._clusterCarouselMarkers = clusterMarkers;
    this._clusterCarouselIndex = 0;
    this._clusterCarouselInterval = 2000; // 2秒切换一次
    
    // 立即显示第一个
    this.showNextClusterInfo();
    
    // 设置定时器
    this._clusterCarouselTimer = setInterval(function() {
      this.showNextClusterInfo();
    }.bind(this), this._clusterCarouselInterval);
  },
  
  /**
   * 停止聚合类型信息窗口轮播
   */
  stopClusterInfoCarousel: function() {
    if (this._clusterCarouselTimer) {
      clearInterval(this._clusterCarouselTimer);
      this._clusterCarouselTimer = null;
    }
    
    // 关闭所有聚合类型信息窗口
    if (this._clusterCarouselMarkers) {
      for (var i = 0; i < this._clusterCarouselMarkers.length; i++) {
        var marker = this._clusterCarouselMarkers[i];
        if (marker._customInfoWindow) {
          marker.closeInfoWindow();
        }
      }
      this._clusterCarouselMarkers = null;
    }
    
    this._clusterCarouselIndex = 0;
  },
  
  /**
   * 显示下一个聚合类型信息窗口
   */
  showNextClusterInfo: function() {
    if (!this._clusterCarouselMarkers || this._clusterCarouselMarkers.length === 0) {
      return;
    }
    
    // 关闭当前显示的信息窗口
    if (this._clusterCarouselIndex > 0) {
      var prevMarker = this._clusterCarouselMarkers[this._clusterCarouselIndex - 1];
      if (prevMarker._customInfoWindow) {
        prevMarker.closeInfoWindow();
      }
    }
    
    // 显示下一个信息窗口
    var currentMarker = this._clusterCarouselMarkers[this._clusterCarouselIndex];
    if (currentMarker._customInfoWindow) {
      
      currentMarker.openInfoWindow(currentMarker._customInfoWindow);
      // 应用自定义样式 - 立即应用
      if (currentMarker._customInfoWindow._applyCustomStyles) {
        currentMarker._customInfoWindow._applyCustomStyles();
      }
    }
    
    // 更新索引，循环显示
    this._clusterCarouselIndex = (this._clusterCarouselIndex + 1) % this._clusterCarouselMarkers.length;
  },
  
  /**
   * 重新启动聚合类型信息窗口轮播
   */
  restartClusterInfoCarousel: function() {
    // 清除手动悬停标志
    this._clusterManualHover = false;
    
    // 如果点类型标记点正在悬停，不启动轮播
    if (this._pointTypeHovering) {
      return;
    }
    
    // 获取当前可见的聚合类型标记点
    var visibleClusterMarkers = [];
    if (this.map) {
      var currentZoom = this.map.getZoom();
      
      for (var i = 0; i < this.markers.length; i++) {
        var marker = this.markers[i];
        if (marker._markerType === 1) {
          var minZoom = marker._minZoomLevel !== undefined ? marker._minZoomLevel : 1;
          var maxZoom = marker._maxZoomLevel !== undefined ? marker._maxZoomLevel : 18;
          
          if (currentZoom >= minZoom && currentZoom <= maxZoom) {
            visibleClusterMarkers.push(marker);
          }
        }
      }
    }
    
    // 重新启动轮播
    if (visibleClusterMarkers.length >= 1) {
      this.startClusterInfoCarousel(visibleClusterMarkers);
    }
  },
  
  /**
   * 渲染标记点和边界
   */
  renderMarkers: function(data) {
    if (!this.map || !window.T) {
      return;
    }
    
    var cfg = this.config;
    var self = this;
    
    
    // 清除旧的标记点和边界
    this.clearMarkers();
    this.clearPolygons();
    
    // 如果没有数据，直接返回
    if (!data || data.length === 0) {
      return;
    }
    
    // 添加新的标记点和边界
    data.forEach(function(item) {
      if (item.lng && item.lat) {
        // 获取标记点类型：1-聚合类型，2-点类型（默认）
        var markerType = item.type || 2;
        
        // 仅点类型（type=2）才绘制边界多边形
        if (markerType === 2 && item.boundary && item.boundary.length > 0) {
          self.drawBoundary(item);
        }
        
        // 绘制标记点
        if (cfg.markerStyle && cfg.markerStyle.showMarker) {
          var point = new T.LngLat(item.lng, item.lat);
          
          // 获取标记点的大小和颜色配置（优先使用自己的配置，否则使用全局配置）
          var markerSize = item.markerSize !== undefined ? item.markerSize : (cfg.markerStyle && cfg.markerStyle.markerSize ? cfg.markerStyle.markerSize : 30);
          var markerColor = item.markerColor || (cfg.markerStyle && cfg.markerStyle.markerColor ? cfg.markerStyle.markerColor : '#FF0000');
          
          // 创建自定义图标
          var icon = new T.Icon({
            iconUrl: self.createMarkerIcon(markerColor, markerSize),
            iconSize: new T.Point(markerSize, markerSize),
            iconAnchor: new T.Point(markerSize / 2, markerSize)
          });
          
          var marker = new T.Marker(point, {icon: icon});
          
          // 设置标记点的z-index较低，确保信息弹窗在上层
          if (marker._icon) {
            marker._icon.style.zIndex = "1000";
          }
          
          // 保存该标记点的缩放级别配置和类型
          marker._minZoomLevel = item.minZoomLevel;
          marker._maxZoomLevel = item.maxZoomLevel;
          marker._markerType = markerType;
          marker._itemData = item; // 保存原始数据，用于合并信息窗口
          
          
          self.map.addOverLay(marker);
          self.markers.push(marker);
          
          // 延迟设置标记点z-index，确保信息弹窗在上层
          setTimeout(function() {
            if (marker._icon) {
              marker._icon.style.zIndex = "1000";
            }
          }, 100);
          
          // 添加自定义信息弹窗和事件
          var point = new T.LngLat(item.lng, item.lat);
          var customInfoWindow = self.createCustomInfoWindow(item, markerType, point);
          if (customInfoWindow) {
            // 保存自定义信息弹窗引用到 marker 对象上
            marker._customInfoWindow = customInfoWindow;
            
            // 根据类型设置不同的交互
            if (markerType === 1) {
              // 聚合类型：悬停显示信息窗口，离开后消失并启动轮播
              
              // 标记是否真正悬停
              marker._isHovering = false;
              marker._hoverTimer = null;
              
              // 鼠标进入标记点
              marker.addEventListener('mouseover', function() {
                // 清除之前的定时器
                if (marker._hoverTimer) {
                  clearTimeout(marker._hoverTimer);
                  marker._hoverTimer = null;
                }
                
                // 设置悬停标志
                marker._isHovering = true;
                
                // 清除轮播重启定时器（如果存在）
                if (self._carouselRestartTimer) {
                  clearTimeout(self._carouselRestartTimer);
                  self._carouselRestartTimer = null;
                }
                
                // 停止轮播并设置手动悬停标志
                self.stopClusterInfoCarousel();
                self._clusterManualHover = true;
                
                // 显示自定义信息弹窗
                if (marker._customInfoWindow) {
                  // 直接打开 InfoWindow
                  marker.openInfoWindow(marker._customInfoWindow);
                  
                  // 立即同步应用关键样式，确保第一次显示位置正确
                  setTimeout(function() {
                    var infoWindowElements = document.querySelectorAll('.tdt-infowindow');
                    console.log('[聚合类型-第一步] InfoWindow数量:', infoWindowElements.length);
                    if (infoWindowElements.length > 0) {
                      var infoWindowElement = infoWindowElements[infoWindowElements.length - 1];
                      var cfg = self.config.infoWindowStyle || {};
                      var styleConfig = cfg.cluster || {};
                      
                      console.log('[聚合类型-第一步] 应用样式前 - 宽度:', infoWindowElement.offsetWidth, '高度:', infoWindowElement.offsetHeight);
                      console.log('[聚合类型-第一步] 应用样式前 - 位置:', {
                        left: infoWindowElement.style.left,
                        top: infoWindowElement.style.top,
                        transform: infoWindowElement.style.transform
                      });
                      
                      // 强制设置宽度为自适应
                      infoWindowElement.style.setProperty('width', 'fit-content', 'important');
                      infoWindowElement.style.setProperty('min-width', styleConfig.minWidth || '0', 'important');
                      infoWindowElement.style.setProperty('max-width', styleConfig.maxWidth || 'none', 'important');
                      
                      // 强制重排
                      infoWindowElement.offsetHeight;
                      
                      console.log('[聚合类型-第一步] 应用样式后 - 宽度:', infoWindowElement.offsetWidth, '高度:', infoWindowElement.offsetHeight);
                      
                      // 直接修正 left 偏移量（应该是宽度的一半，实现居中）
                      var correctLeft = -Math.round(infoWindowElement.offsetWidth / 2);
                      console.log('[聚合类型-第一步] 修正位置 - 当前left:', infoWindowElement.style.left, '正确left:', correctLeft + 'px');
                      infoWindowElement.style.left = correctLeft + 'px';
                      
                      // 检查标题元素的实际样式
                      setTimeout(function() {
                        var titleElement = infoWindowElement.querySelector('.info-title');
                        if (titleElement) {
                          var computedStyle = window.getComputedStyle(titleElement);
                          console.log('[样式检查] 标题实际样式:', {
                            fontSize: computedStyle.fontSize,
                            color: computedStyle.color,
                            fontWeight: computedStyle.fontWeight
                          });
                        }
                        
                        // 检查内容元素的实际样式
                        var contentElement = infoWindowElement.querySelector('.info-content');
                        if (contentElement) {
                          var contentComputedStyle = window.getComputedStyle(contentElement);
                          console.log('[样式检查] 内容实际样式:', {
                            fontSize: contentComputedStyle.fontSize,
                            color: contentComputedStyle.color
                          });
                        }
                        
                        // 检查InfoWindow容器的样式
                        var containerComputedStyle = window.getComputedStyle(infoWindowElement);
                        console.log('[样式检查] 容器实际样式:', {
                          fontSize: containerComputedStyle.fontSize,
                          color: containerComputedStyle.color
                        });
                      }, 50);
                      
                      setTimeout(function() {
                        console.log('[聚合类型-第一步] 修正后 - 位置:', {
                          left: infoWindowElement.style.left,
                          top: infoWindowElement.style.top,
                          transform: infoWindowElement.style.transform
                        });
                      }, 10);
                    }
                  }, 0);
                  
                  // 应用完整样式
                  setTimeout(function() {
                    if (marker._customInfoWindow._applyCustomStyles) {
                      marker._customInfoWindow._applyCustomStyles();
                    }
                  }, 50);
                }
              });
              
              // 定义离开处理函数
              var handleMouseLeave = function(eventName) {
                // 设置一个短延迟，确认鼠标真的离开了
                if (marker._hoverTimer) {
                  clearTimeout(marker._hoverTimer);
                }
                
                // 立即关闭信息窗口，不需要延迟
                marker._isHovering = false;
                marker.closeInfoWindow();
                
                // 清除之前的轮播重启定时器（防抖）
                if (self._carouselRestartTimer) {
                  clearTimeout(self._carouselRestartTimer);
                }
                
                // 延迟启动轮播，确保信息窗口完全关闭后再启动
                self._carouselRestartTimer = setTimeout(function() {
                  self._clusterManualHover = false;
                  self.restartClusterInfoCarousel();
                  self._carouselRestartTimer = null;
                }, 600); // 延迟600ms启动轮播
              };
              
              // 尝试监听多个可能的离开事件
              marker.addEventListener('mouseout', function() {
                handleMouseLeave('mouseout');
              });
              
              marker.addEventListener('mouseleave', function() {
                handleMouseLeave('mouseleave');
              });
              
              
              // 点击时飞行到该位置
              marker.addEventListener('click', function() {
                var targetZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.clusterZoom) || 16;
                var targetPoint = new T.LngLat(item.lng, item.lat);
                
                // 使用centerAndZoom同时设置中心点和缩放级别
                self.map.centerAndZoom(targetPoint, targetZoom);
                
                // 触发标记点点击事件
                self.emit('markerClick', {
                  lng: item.lng,
                  lat: item.lat,
                  title: item.title || '',
                  location: item.location || '',
                  content: item.content || ''
                });
              });
            } else {
              // 点类型：悬停显示信息窗口，支持移动到信息窗口上
              
              // 鼠标进入标记点
              marker.addEventListener('mouseover', function() {
                // 取消之前的关闭定时器
                if (marker._closeTimer) {
                  clearTimeout(marker._closeTimer);
                  marker._closeTimer = null;
                }
                
                // 暂停聚合类型轮播，避免干扰点类型信息窗口
                self.stopClusterInfoCarousel();
                self._pointTypeHovering = true;
                
                // 显示自定义信息弹窗
                if (marker._customInfoWindow) {
                  // 直接打开 InfoWindow
                  marker.openInfoWindow(marker._customInfoWindow);
                  
                  // 立即同步应用关键样式，确保第一次显示位置正确
                  setTimeout(function() {
                    var infoWindowElements = document.querySelectorAll('.tdt-infowindow');
                    if (infoWindowElements.length > 0) {
                      var infoWindowElement = infoWindowElements[infoWindowElements.length - 1];
                      var cfg = self.config.infoWindowStyle || {};
                      var styleConfig = cfg.point || {};
                      
                      // 强制设置宽度为自适应
                      infoWindowElement.style.setProperty('width', 'fit-content', 'important');
                      infoWindowElement.style.setProperty('min-width', styleConfig.minWidth || '0', 'important');
                      infoWindowElement.style.setProperty('max-width', styleConfig.maxWidth || 'none', 'important');
                      
                      // 强制重排
                      infoWindowElement.offsetHeight;
                      
                      // 直接修正 left 偏移量（应该是宽度的一半，实现居中）
                      var correctLeft = -Math.round(infoWindowElement.offsetWidth / 2);
                      infoWindowElement.style.left = correctLeft + 'px';
                    }
                  }, 0);
                  
                  // 应用完整样式
                  setTimeout(function() {
                    if (marker._customInfoWindow._applyCustomStyles) {
                      marker._customInfoWindow._applyCustomStyles();
                    }
                  }, 50);
                }
                
                // 延迟获取信息窗口DOM元素并添加事件监听
                setTimeout(function() {
                  self.addInfoWindowHoverListenersForPoint(marker, marker._customInfoWindow);
                }, 100);
              });
              
              // 鼠标离开标记点
              marker.addEventListener('mouseout', function() {
                // 延迟关闭，给用户时间移动到信息窗口上
                marker._closeTimer = setTimeout(function() {
                  marker.closeInfoWindow();
                  
                  // 清除之前的轮播重启定时器（防抖）
                  if (self._carouselRestartTimer) {
                    clearTimeout(self._carouselRestartTimer);
                  }
                  
                  // 延迟恢复聚合类型轮播，确保点类型窗口完全关闭后再启动
                  self._carouselRestartTimer = setTimeout(function() {
                    self._pointTypeHovering = false;
                    self.restartClusterInfoCarousel();
                    self._carouselRestartTimer = null;
                  }, 200); // 额外延迟200ms
                }, 500);
              });
              
              // 点击触发飞行和事件
              marker.addEventListener('click', function() {
                var targetZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.pointZoom) || 16;
                var targetPoint = new T.LngLat(item.lng, item.lat);
                
                // 使用centerAndZoom同时设置中心点和缩放级别
                self.map.centerAndZoom(targetPoint, targetZoom);
                
                // 触发标记点点击事件
                self.emit('markerClick', {
                  lng: item.lng,
                  lat: item.lat,
                  title: item.title || '',
                  location: item.location || '',
                  content: item.content || ''
                });
              });
            }
          } else {
            // 即使没有信息窗口，也要触发点击飞行和事件
            marker.addEventListener('click', function() {
              // 飞行到该位置
              var targetZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.pointZoom) || 16;
              
              // 使用item的坐标重新创建point对象
              var targetPoint = new T.LngLat(item.lng, item.lat);
              
              // 使用centerAndZoom同时设置中心点和缩放级别
              self.map.centerAndZoom(targetPoint, targetZoom);
              
              self.emit('markerClick', {
                lng: item.lng,
                lat: item.lat,
                title: item.title || '',
                location: item.location || '',
                content: item.content || ''
              });
            });
          }
        }
      }
    });
    
    // 根据当前缩放级别更新标记点显示状态
    this.updateMarkersVisibility();
  },
  
  /**
   * 绘制边界多边形
   */
  drawBoundary: function(item) {
    if (!item.boundary || item.boundary.length < 3) {
      return;
    }
    
    var points = [];
    for (var i = 0; i < item.boundary.length; i++) {
      var pt = item.boundary[i];
      if (pt.lng && pt.lat) {
        points.push(new T.LngLat(pt.lng, pt.lat));
      }
    }
    
    if (points.length < 3) {
      return;
    }
    
    // 创建多边形
    var polygon = new T.Polygon(points, {
      color: item.borderColor || '#ff0000',
      weight: item.borderWidth || 2,
      opacity: 0.8,
      fillColor: item.borderColor || '#ff0000',
      fillOpacity: 0.1
    });
    
    // 保存该多边形的缩放级别配置（与标记点使用相同的配置）
    polygon._minZoomLevel = item.minZoomLevel;
    polygon._maxZoomLevel = item.maxZoomLevel;
    
    this.map.addOverLay(polygon);
    this.polygons.push(polygon);
    
    // 为多边形添加点击事件
    var self = this;
    var infoContent = this.createInfoWindowContent(item);
    if (infoContent) {
      polygon.addEventListener('click', function(e) {
        // 创建信息窗口，禁用关闭按钮
        var infoWin = new T.InfoWindow({
          closeButton: false,
          autoPan: true
        });
        infoWin.setContent(infoContent);
        infoWin.setLngLat(e.lnglat);
        self.map.addOverLay(infoWin);
        
        // 应用自定义样式 - 使用重试机制
        var retryCount = 0;
        var maxRetries = 10;
        
        function applyPolygonStyles() {
          var infoWindowElements = document.querySelectorAll('.tdt-infowindow');
          var infoWindowElement = infoWindowElements[infoWindowElements.length - 1];
          
          if (infoWindowElement) {
            var cfg = self.config.infoWindowStyle || {};
            var style = cfg.point || {};
            
            // 立即应用内联样式，确保第一次就能看到效果
            infoWindowElement.style.backgroundColor = style.backgroundColor || '#ffffff';
            infoWindowElement.style.borderColor = style.borderColor || '#ddd';
            infoWindowElement.style.borderWidth = style.borderWidth || '1px';
            infoWindowElement.style.borderRadius = style.borderRadius || '8px';
            infoWindowElement.style.boxShadow = style.boxShadow || '0 4px 20px rgba(0,0,0,0.15)';
            infoWindowElement.style.padding = style.padding || '15px';
            infoWindowElement.style.minWidth = style.minWidth || '250px';
            infoWindowElement.style.maxWidth = style.maxWidth || '400px';
            infoWindowElement.style.fontSize = style.fontSize || '14px';
            infoWindowElement.style.color = style.color || '#333';
            
            // 同时应用CSS变量，确保后续样式正确
            infoWindowElement.style.setProperty('--custom-bg-color', style.backgroundColor || '#ffffff');
            infoWindowElement.style.setProperty('--custom-border-color', style.borderColor || '#ddd');
            infoWindowElement.style.setProperty('--custom-border-width', style.borderWidth || '1px');
            infoWindowElement.style.setProperty('--custom-border-radius', style.borderRadius || '8px');
            infoWindowElement.style.setProperty('--custom-box-shadow', style.boxShadow || '0 4px 20px rgba(0,0,0,0.15)');
            infoWindowElement.style.setProperty('--custom-padding', style.padding || '15px');
            infoWindowElement.style.setProperty('--custom-min-width', style.minWidth || '250px');
            infoWindowElement.style.setProperty('--custom-max-width', style.maxWidth || '400px');
            infoWindowElement.style.setProperty('--custom-font-size', style.fontSize || '14px');
            infoWindowElement.style.setProperty('--custom-color', style.color || '#333');
            infoWindowElement.style.setProperty('--custom-title-font-size', style.titleFontSize || '16px');
            infoWindowElement.style.setProperty('--custom-title-color', style.titleColor || '#000');
            infoWindowElement.style.setProperty('--custom-title-margin-bottom', style.titleMarginBottom || '8px');
            infoWindowElement.style.setProperty('--custom-location-color', style.locationColor || '#666');
            infoWindowElement.style.setProperty('--custom-location-margin-bottom', style.locationMarginBottom || '10px');
            infoWindowElement.style.setProperty('--custom-content-margin-bottom', style.contentMarginBottom || '10px');
            infoWindowElement.style.setProperty('--custom-image-margin-top', style.imageMarginTop || '12px');
            infoWindowElement.style.setProperty('--custom-image-border-color', style.imageBorderColor || '#eee');
            infoWindowElement.style.setProperty('--custom-image-border-width', style.imageBorderWidth || '1px');
            infoWindowElement.style.setProperty('--custom-image-border-radius', style.imageBorderRadius || '6px');
            infoWindowElement.style.setProperty('--custom-image-tip-font-size', style.imageTipFontSize || '12px');
            infoWindowElement.style.setProperty('--custom-image-tip-color', style.imageTipColor || '#999');
            
          } else if (retryCount < maxRetries) {
            retryCount++;
            setTimeout(applyPolygonStyles, 30);
          }
        }
        
        // 立即尝试应用样式
        applyPolygonStyles();
      });
    }
  },
  
  /**
   * 创建自定义信息弹窗覆盖物 - 使用原生InfoWindow + CSS覆盖
   * @param item 标记点数据
   * @param markerType 标记点类型：1-聚合类型，2-点类型
   * @param position 弹窗位置
   */
  createCustomInfoWindow: function(item, markerType, position) {
    var title = item.title;
    if (!title && !item.content && !item.location) {
      return null;
    }
    
    var self = this;
    var type = markerType || 2;
    var cfg = this.config.infoWindowStyle || {};
    
    // 根据类型获取样式配置
    var style = type === 1 ? (cfg.cluster || {}) : (cfg.point || {});
    
    // 创建InfoWindow
    var infoWin = new T.InfoWindow({
      closeButton: false,
      autoPan: true,
      minWidth: 0,
      maxWidth: 1000
    });
    
    // 构建内容
    var content = this.buildInfoWindowContent(item, style, type);
    infoWin.setContent(content);
    infoWin.setLngLat(position);
    
    // 添加自定义样式类
    infoWin._customStyle = style;
    infoWin._markerType = type;
    infoWin._position = position; // 保存位置信息，用于后续重新定位
    
    // 存储样式配置，在信息弹窗打开时应用
    infoWin._applyCustomStyles = function() {
      // 在InfoWindow打开时应用样式，传递 InfoWindow 对象
      self._applyInfoWindowStyles(style, infoWin);
    };
    
    return infoWin;
  },
  
  /**
   * 构建信息弹窗内容
   */
  buildInfoWindowContent: function(item, style, type) {
    var html = '';
    
    // 标题 - 简化样式
    if (item.title) {
      html += '<div class="info-title">' + item.title + '</div>';
    }
    
    // 位置 - 仅点类型（type=2）显示
    if (type === 2 && item.location) {
      html += '<div class="info-location">' + item.location + '</div>';
    }
    
    // 内容
    if (item.content) {
      html += '<div class="info-content">' + item.content + '</div>';
    }
    
    // GIF图片 - 仅点类型（type=2）显示
    if (type === 2 && item.gif) {
      var imgId = 'tdt-img-' + Math.random().toString(36).substr(2, 9);
      html += '<div class="info-image" onclick="window.tdtShowImage(\'' + item.gif + '\')">';
      html += '<img id="' + imgId + '" src="' + item.gif + '" />';
      html += '<div class="image-tip">点击查看大图</div>';
      html += '</div>';
    }
    
    return html;
  },

  /**
   * 创建信息窗口内容
   * @param item 标记点数据
   * @param markerType 标记点类型：1-聚合类型，2-点类型
   */
  createInfoWindowContent: function(item, markerType) {
    var title = item.title;
    if (!title && !item.content && !item.location) {
      return null;
    }
    
    var self = this;
    var type = markerType || 2;
    var cfg = this.config.infoWindowStyle || {};
    
    // 根据类型获取样式配置
    var style = type === 1 ? (cfg.cluster || {}) : (cfg.point || {});
    
    // 构建容器样式
    var containerStyle = '';
    if (type === 1) {
      containerStyle = 'padding:' + (style.padding || '2px') + ';min-width:' + (style.minWidth || '80px') + ';max-width:' + (style.maxWidth || '120px') + ';color:' + (style.color || '#333') + ';font-size:' + (style.fontSize || '12px') + ';';
    } else {
      containerStyle = 'padding:' + (style.padding || '1px') + ';min-width:' + (style.minWidth || '200px') + ';color:' + (style.color || '#333') + ';font-size:' + (style.fontSize || '14px') + ';';
    }
    
    var html = '<div style="' + containerStyle + '">';
    
    // 标题
    if (title) {
      html += '<div style="font-size:' + (style.titleFontSize || '13px') + ';font-weight:bold;margin-bottom:' + (style.titleMarginBottom || '4px') + ';color:' + (style.titleColor || '#000') + ';">' + title + '</div>';
    }
    
    // 位置 - 仅点类型（type=2）显示
    if (type === 2 && item.location) {
      html += '<div style="margin-bottom:' + (style.locationMarginBottom || '6px') + ';color:' + (style.locationColor || '#666') + ';"><svg style="width:14px;height:14px;vertical-align:middle;margin-right:4px;" viewBox="0 0 24 24"><path fill="' + (style.locationColor || '#666') + '" d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg>' + item.location + '</div>';
    }
    
    // 内容
    if (item.content) {
      html += '<div style="margin-bottom:' + (type === 2 ? (style.contentMarginBottom || '6px') : '6px') + ';">' + item.content + '</div>';
    }
    
    // GIF图片 - 仅点类型（type=2）显示
    if (type === 2 && item.gif) {
      var imgId = 'tdt-img-' + Math.random().toString(36).substr(2, 9);
      html += '<div style="margin-top:' + (style.imageMarginTop || '8px') + ';cursor:pointer;" onclick="window.tdtShowImage(\'' + item.gif + '\')">';
      html += '<img id="' + imgId + '" src="' + item.gif + '" style="max-width:100%;height:auto;border:' + (style.imageBorderWidth || '2px') + ' solid ' + (style.imageBorderColor || '#ddd') + ';border-radius:' + (style.imageBorderRadius || '4px') + ';" />';
      html += '<div style="text-align:center;margin-top:4px;font-size:' + (style.imageTipFontSize || '12px') + ';color:' + (style.imageTipColor || '#666') + ';">点击查看大图</div>';
      html += '</div>';
    }
    
    html += '</div>';
    
    // 确保全局函数存在
    if (type === 2) {
      this.ensureImageViewerExists();
    }
    
    return html;
  },
  
  /**
   * 将十六进制颜色转换为RGB
   */
  hexToRgb: function(hex) {
    // 移除 # 号
    hex = hex.replace('#', '');
    
    // 如果是3位简写，转换为6位
    if (hex.length === 3) {
      hex = hex.split('').map(function(char) {
        return char + char;
      }).join('');
    }
    
    // 转换为RGB
    var r = parseInt(hex.substring(0, 2), 16);
    var g = parseInt(hex.substring(2, 4), 16);
    var b = parseInt(hex.substring(4, 6), 16);
    
    return r + ',' + g + ',' + b;
  },

  /**
   * 确保图片查看器存在
   */
  ensureImageViewerExists: function() {
    if (window.tdtShowImage) {
      return;
    }
    
    var self = this;
    
    // 创建全局图片预览函数
    window.tdtShowImage = function(imageSrc) {
      // 获取图片查看器样式配置
      var cfg = self.config.infoWindowStyle || {};
      var viewerStyle = cfg.imageViewer || {};
      
      // 处理遮罩背景颜色和透明度
      var overlayBgColor = viewerStyle.overlayBackgroundColor || '#000000';
      var overlayOpacity = viewerStyle.overlayOpacity || '0.5';
      
      // 创建遮罩层
      var overlay = document.createElement('div');
      overlay.id = 'tdt-image-overlay';
      overlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(' + self.hexToRgb(overlayBgColor) + ',' + overlayOpacity + ');z-index:9999;display:flex;align-items:center;justify-content:center;cursor:pointer;';
      
      // 创建图片容器
      var container = document.createElement('div');
      container.style.cssText = 'position:relative;cursor:default;width:30vw;height:30vh;display:flex;align-items:center;justify-content:center;';
      
      // 创建图片
      var img = document.createElement('img');
      img.src = imageSrc;
      
      // 应用图片样式配置
      var imgBorderRadius = viewerStyle.imageBorderRadius || '8px';
      var imgBoxShadow = viewerStyle.imageBoxShadow || '0 8px 32px rgba(0,0,0,0.6)';
      var imgBorderColor = viewerStyle.imageBorderColor || '#ffffff';
      var imgBorderWidth = viewerStyle.imageBorderWidth || '2px';
      var imgBorderStyle = viewerStyle.imageBorderStyle || 'solid';
      
      // 获取最大尺寸比例配置
      var maxScalePercent = viewerStyle.imageMaxScalePercent || '80';
      
      // 图片按比例缩放，使用单个比例值控制最大尺寸
      img.style.cssText = 'max-width:' + maxScalePercent + 'vw;max-height:' + maxScalePercent + 'vh;width:auto;height:auto;display:block;border-radius:' + imgBorderRadius + ';box-shadow:' + imgBoxShadow + ';border:' + imgBorderWidth + ' ' + imgBorderStyle + ' ' + imgBorderColor + ';';
      
      // 组装元素
      container.appendChild(img);
      overlay.appendChild(container);
      document.body.appendChild(overlay);
      
      // 点击关闭
      var closeImage = function() {
        document.body.removeChild(overlay);
      };
      
      // 点击背景关闭，点击图片和图片容器不关闭
      overlay.addEventListener('click', function(e) {
        if (e.target === overlay) {
          closeImage();
        }
      });
      
      // 阻止图片容器的点击事件冒泡
      container.addEventListener('click', function(e) {
        e.stopPropagation();
      });
      
      // ESC键关闭
      var keyHandler = function(e) {
        if (e.key === 'Escape') {
          closeImage();
          document.removeEventListener('keydown', keyHandler);
        }
      };
      document.addEventListener('keydown', keyHandler);
    };
  },
  
  /**
   * 创建标记点图标（使用SVG）
   */
  createMarkerIcon: function(color, size) {
    var svg = '<svg xmlns="http://www.w3.org/2000/svg" width="' + size + '" height="' + size + '" viewBox="0 0 24 24">' +
              '<path fill="' + color + '" d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/>' +
              '</svg>';
    return 'data:image/svg+xml;base64,' + btoa(svg);
  },
  
  /**
   * 清除所有标记点
   */
  clearMarkers: function() {
    if (this.map && this.markers.length > 0) {
      for (var i = 0; i < this.markers.length; i++) {
        this.map.removeOverLay(this.markers[i]);
      }
      this.markers = [];
    }
  },
  
  /**
   * 清除所有多边形
   */
  clearPolygons: function() {
    if (this.map && this.polygons.length > 0) {
      for (var i = 0; i < this.polygons.length; i++) {
        this.map.removeOverLay(this.polygons[i]);
      }
      this.polygons = [];
    }
  },
  
  /**
   * 绘制
   * @param data
   * @param config 不一定有
   */
  render: function (data, config) {
    var cfg = this.mergeConfig(config);
    var rawData = data; // 保存原始数据（可能是数组，因为 DataV 框架可能已经提取了 source）
    var dataSourceCenter = null; // 数据源中的中心点
    var markersData = []; // 标记点数据
    
    console.log('[天地图组件] render 函数被调用');
    console.log('[天地图组件] 传入的 data：', rawData);
    console.log('[天地图组件] 传入的 config：', config);
    console.log('[天地图组件] mergeConfig 后的 cfg：', cfg);
    console.log('[天地图组件] this.config：', this.config);
    console.log('[天地图组件] 数据类型：', typeof rawData, Array.isArray(rawData) ? '数组' : '对象');
    
    // DataV 框架根据 fields 定义传递数据
    // 支持的数据格式：
    // 格式1：数组格式，其中某个元素有 centerPoint: true 属性，标记为中心点
    // 格式2：{source: {lng, lat, data: [...]}} - source 是对象
    // 格式3：{center: {lng, lat}, source: [...]} - 传统格式
    
    // 方案1：如果 data 是数组格式（DataV 最可能传递的格式）
    if (Array.isArray(rawData)) {
      // 检查数组中是否有标记为中心点的元素（centerPoint: true）
      var centerItem = null;
      
      for (var i = 0; i < rawData.length; i++) {
        var item = rawData[i];
        // 所有元素都作为标记点数据（包括 centerPoint: true 的元素）
        markersData.push(item);
        
        // 如果找到中心点标记，提取中心点信息（用于设置地图中心）
        if (item.centerPoint === true && item.lng !== undefined && item.lat !== undefined) {
          if (!centerItem) {
            centerItem = item;
            console.log('[天地图组件] 从数组中找到中心点标记元素：', centerItem);
          }
        }
      }
      
      // 如果找到了中心点标记，提取中心点信息
      if (centerItem) {
        dataSourceCenter = {
          lng: centerItem.lng,
          lat: centerItem.lat,
          type: centerItem.type || 2  // 保存中心点类型，默认为点类型（2）
        };
        console.log('[天地图组件] 提取的中心点：', dataSourceCenter);
        console.log('[天地图组件] 中心点类型：', dataSourceCenter.type === 1 ? '聚合类型' : '点类型');
      }
      
      console.log('[天地图组件] 标记点数据数量：', markersData.length, '（包含所有元素，包括中心点标记元素）');
    }
    // 方案2：如果 data 是对象格式
    else if (rawData && typeof rawData === 'object' && !Array.isArray(rawData)) {
      // 检查是否是格式2：{source: {lng, lat, data: [...]}}
      if (rawData.source && typeof rawData.source === 'object' && !Array.isArray(rawData.source)) {
        if (rawData.source.lng !== undefined && rawData.source.lat !== undefined) {
          dataSourceCenter = {
            lng: rawData.source.lng,
            lat: rawData.source.lat
          };
          console.log('[天地图组件] 从 source 对象中提取中心点：', dataSourceCenter);
        }
        if (rawData.source.data && Array.isArray(rawData.source.data)) {
          markersData = rawData.source.data;
          console.log('[天地图组件] 从 source.data 中提取标记点，数量：', markersData.length);
        }
      }
      // 检查是否是格式3：{center: {lng, lat}, source: [...]}
      else if (rawData.center && rawData.center.lng !== undefined && rawData.center.lat !== undefined) {
        dataSourceCenter = rawData.center;
        console.log('[天地图组件] 从 center 对象中提取中心点：', dataSourceCenter);
        if (rawData.source && Array.isArray(rawData.source)) {
          markersData = rawData.source;
          console.log('[天地图组件] 从 source 数组中提取标记点，数量：', markersData.length);
        }
      }
      // 检查是否是其他对象格式
      else if (rawData.source && Array.isArray(rawData.source)) {
        markersData = rawData.source;
        console.log('[天地图组件] 从 source 数组中提取标记点（无中心点），数量：', markersData.length);
      }
    }
    
    // 处理标记点数据
    data = this.data(markersData);
    console.log('[天地图组件] 处理后的标记点数据数量：', data ? data.length : 0);
    
    // 检查地图初始化状态
    console.log('[天地图组件] 地图初始化状态检查：');
    console.log('[天地图组件] - this.map 是否存在：', !!this.map);
    console.log('[天地图组件] - this.tdtLoaded：', this.tdtLoaded);
    
    // 保存数据源中心点，供 initMap 使用
    var mapJustInitialized = false;
    
    // 如果地图还未初始化，等待初始化完成
    if (!this.map && this.tdtLoaded) {
      console.log('[天地图组件] 地图未初始化，开始初始化地图...');
      // 保存数据源中心点到实例变量，供 initMap 使用
      this._pendingCenter = dataSourceCenter;
      // 根据中心点类型确定缩放级别
      if (dataSourceCenter) {
        var centerType = dataSourceCenter.type || 2;
        if (centerType === 1) {
          this._pendingZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.clusterZoom) || cfg.zoom;
        } else {
          this._pendingZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.pointZoom) || cfg.zoom;
        }
      } else {
        this._pendingZoom = cfg.zoom;
      }
      this.initMap();
      mapJustInitialized = true;
      console.log('[天地图组件] 地图初始化完成，this.map 是否存在：', !!this.map);
    } else if (!this.map && !this.tdtLoaded) {
      console.log('[天地图组件] 地图未初始化且天地图API未加载，等待API加载...');
      // 保存数据源中心点，等待API加载完成后使用
      this._pendingCenter = dataSourceCenter;
      // 根据中心点类型确定缩放级别
      if (dataSourceCenter) {
        var centerType = dataSourceCenter.type || 2;
        if (centerType === 1) {
          this._pendingZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.clusterZoom) || cfg.zoom;
        } else {
          this._pendingZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.pointZoom) || cfg.zoom;
        }
      } else {
        this._pendingZoom = cfg.zoom;
      }
    }
    
    // 更新地图配置
    if (this.map) {
      console.log('[天地图组件] 地图已存在，开始更新地图配置...');
      // 确定使用哪个中心点和缩放级别
      var finalCenter = null;
      var finalZoom = null;
      
      console.log('[天地图组件] 确定中心点和缩放级别：');
      console.log('[天地图组件] - dataSourceCenter：', dataSourceCenter);
      console.log('[天地图组件] - cfg.center：', cfg.center);
      console.log('[天地图组件] - cfg.zoom：', cfg.zoom);
      console.log('[天地图组件] - cfg.markerFlyToZoom：', cfg.markerFlyToZoom);
      
      if (dataSourceCenter) {
        // 数据源中有中心点时，根据中心点的类型确定缩放级别
        finalCenter = {
          lng: dataSourceCenter.lng,
          lat: dataSourceCenter.lat
        };
        
        // 根据中心点类型确定缩放级别
        var centerType = dataSourceCenter.type || 2; // 默认为点类型（2）
        if (centerType === 1) {
          // 聚合类型，使用聚合类型缩放级别
          finalZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.clusterZoom) || cfg.zoom;
          console.log('[天地图组件] 使用数据源中心点 + 聚合类型缩放级别');
          console.log('[天地图组件] 中心点类型：聚合类型（type=1）');
        } else {
          // 点类型（type=2 或未设置），使用点类型缩放级别
          finalZoom = (cfg.markerFlyToZoom && cfg.markerFlyToZoom.pointZoom) || cfg.zoom;
          console.log('[天地图组件] 使用数据源中心点 + 点类型缩放级别');
          console.log('[天地图组件] 中心点类型：点类型（type=' + centerType + '）');
        }
        console.log('[天地图组件] 中心点：', finalCenter);
        console.log('[天地图组件] 缩放级别：', finalZoom);
      } else {
        // 数据源中没有中心点时（所有 centerPoint 都是 false），使用 datav 中配置的中心点和默认缩放级别
        finalCenter = cfg.center;
        finalZoom = cfg.zoom;
        console.log('[天地图组件] 使用 datav 配置的中心点 + 默认缩放级别');
        console.log('[天地图组件] 中心点：', finalCenter);
        console.log('[天地图组件] 缩放级别：', finalZoom);
      }
      
      // 更新中心点和缩放级别
      if (finalCenter) {
        var centerPoint = new T.LngLat(finalCenter.lng, finalCenter.lat);
        var self = this;
        
        // 在设置之前先获取当前地图的中心点
        var beforeCenter = null;
        var beforeZoom = null;
        if (self.map) {
          try {
            beforeCenter = self.map.getCenter();
            beforeZoom = self.map.getZoom();
          } catch (e) {
            console.log('[天地图组件] 获取当前地图中心点失败（可能地图还未完全初始化）');
          }
        }
        
        console.log('[天地图组件] ========== 地图中心点和缩放级别设置 ==========');
        console.log('[天地图组件] 【设置前】当前地图中心点：', beforeCenter ? '经度 = ' + beforeCenter.getLng() + '，纬度 = ' + beforeCenter.getLat() : '无法获取');
        console.log('[天地图组件] 【设置前】当前地图缩放级别：', beforeZoom !== null ? beforeZoom : '无法获取');
        console.log('[天地图组件] 【要设置】目标中心点：经度 =', finalCenter.lng, '，纬度 =', finalCenter.lat);
        console.log('[天地图组件] 【要设置】目标缩放级别：', finalZoom);
        console.log('[天地图组件] 数据源中心点：', dataSourceCenter ? '有（' + dataSourceCenter.lng + ', ' + dataSourceCenter.lat + '）' : '无');
        
        // 如果地图刚初始化，立即设置中心点（不延迟）
        // 否则使用 setTimeout 确保在地图完全初始化后再设置中心点
        var setCenterFunction = function() {
          if (self.map) {
            self.map.centerAndZoom(centerPoint, finalZoom);
            
            // 设置后立即获取地图中心点
            var afterCenter = null;
            var afterZoom = null;
            try {
              afterCenter = self.map.getCenter();
              afterZoom = self.map.getZoom();
            } catch (e) {
              console.log('[天地图组件] 获取设置后的地图中心点失败');
            }
            
            console.log('[天地图组件] 【设置后】实际地图中心点：', afterCenter ? '经度 = ' + afterCenter.getLng() + '，纬度 = ' + afterCenter.getLat() : '无法获取');
            console.log('[天地图组件] 【设置后】实际地图缩放级别：', afterZoom !== null ? afterZoom : '无法获取');
            
            // 对比设置前后的差异
            if (beforeCenter && afterCenter) {
              var lngDiff = Math.abs(afterCenter.getLng() - finalCenter.lng);
              var latDiff = Math.abs(afterCenter.getLat() - finalCenter.lat);
              console.log('[天地图组件] 【对比】目标中心点与设置后中心点的差异：经度差 =', lngDiff.toFixed(6), '，纬度差 =', latDiff.toFixed(6));
              if (lngDiff > 0.0001 || latDiff > 0.0001) {
                console.warn('[天地图组件] ⚠️ 警告：设置后的中心点与目标中心点不一致！');
              } else {
                console.log('[天地图组件] ✅ 设置成功：中心点已正确设置');
              }
            }
            
            console.log('[天地图组件] ============================================');
          }
        };
        
        // 如果地图刚初始化，立即设置中心点（不延迟）
        // 否则使用 setTimeout 确保在地图完全初始化后再设置中心点
        if (mapJustInitialized) {
          console.log('[天地图组件] 地图刚初始化，立即设置中心点（不延迟）');
          setCenterFunction();
        } else {
          console.log('[天地图组件] 地图已存在，延迟100ms设置中心点');
          setTimeout(setCenterFunction, 100);
        }
      }
      
      // 更新控制选项
      if (cfg.enableZoom) {
        this.map.enableScrollWheelZoom();
      } else {
        this.map.disableScrollWheelZoom();
      }
      
      if (cfg.enableDrag) {
        this.map.enableDrag();
      } else {
        this.map.disableDrag();
      }
      
      // 更新地名标注图层
      this.updateAnnotationLayer();
      
      // 渲染标记点
      this.renderMarkers(data);
      
      // 在渲染标记点后再次确保中心点设置正确（防止被其他操作覆盖）
      if (finalCenter) {
        var centerPoint = new T.LngLat(finalCenter.lng, finalCenter.lat);
        this.map.centerAndZoom(centerPoint, finalZoom);
        console.log('[天地图组件] 渲染标记点后，重新确认中心点设置');
      }
    } else {
      console.log('[天地图组件] 地图不存在，无法更新配置');
      console.log('[天地图组件] - this.map：', this.map);
      console.log('[天地图组件] - this.tdtLoaded：', this.tdtLoaded);
      
      if (this.map) {
        // 如果地图已存在但没有新数据，只更新标记点显示状态
        this.updateMarkersVisibility();
      }
    }
    
    // 更新样式
    this.updateStyle();
  },
  
  /**
   * 飞行至指定位置（交互动作）
   * @param fields 包含 lng, lat, zoom 的对象
   */
  flyTo: function(fields) {
    if (!this.map || !fields) {
      return;
    }
    
    if (!fields.lng || !fields.lat) {
      console.warn('flyTo 需要提供有效的经纬度坐标');
      return;
    }
    
    var targetPoint = new T.LngLat(fields.lng, fields.lat);
    var targetZoom = fields.zoom !== undefined ? fields.zoom : this.config.zoom;
    
    // 使用centerAndZoom同时设置中心点和缩放级别
    this.map.centerAndZoom(targetPoint, targetZoom);
    
  },
  
  /**
   * 显示组件（交互动作）
   */
  show: function() {
    this.container.show();
  },
  
  /**
   * 隐藏组件（交互动作）
   */
  hide: function() {
    this.container.hide();
  },
  
  /**
   * 调整大小
   * @param width
   * @param height
   */
  resize: function (width, height) {
    this.updateLayout(width, height);
    
    // 重新调整地图大小
    if (this.map) {
      setTimeout(function() {
        this.map.checkResize();
      }.bind(this), 100);
    }
  },
  
  /**
   * 每个组件根据自身需要,从主题中获取颜色 覆盖到自身配置的颜色中.
   */
  setColors: function () {
    // 可以根据主题设置标记点颜色等
  },
  
  /**
   * 数据,设置和获取数据
   * @param data
   * @returns {*|number}
   */
  data: function (data) {
    if (data) {
      this._data = data;
    }
    return this._data;
  },
  
  /**
   * 更新配置
   * 优先级: config.colors > config.theme > this.config.theme > this.config.colors
   * [注] 有数组的配置一定要替换
   * @param config
   * @private
   */
  mergeConfig: function (config) {
    if (!config) {
      return this.config;
    }
    this.config.theme = _.defaultsDeep(config.theme || {}, this.config.theme);
    this.setColors();
    this.config = _.defaultsDeep(config || {}, this.config);
    return this.config;
  },
  
  /**
   * 更新布局
   */
  updateLayout: function () {
    this.container.css({
      'width': '100%',
      'height': '100%',
      'margin': '0',
      'padding': '0',
      'overflow': 'hidden',
      'position': 'relative'
    });
    
    // 确保地图容器也铺满
    if (this.mapContainer) {
      $(this.mapContainer).css({
        'width': '100%',
        'height': '100%',
        'position': 'absolute',
        'top': '0',
        'left': '0',
        'margin': '0',
        'padding': '0'
      });
    }
  },
  
  /**
   * 更新样式
   */
  updateStyle: function () {
    this.container.css({
      'width': '100%',
      'height': '100%',
      'margin': '0',
      'padding': '0',
      'overflow': 'hidden',
      'position': 'relative'
    });
  },
  
  /**
   * 销毁组件
   */
  destroy: function() {
    // 清除标记点和多边形
    this.clearMarkers();
    this.clearPolygons();
    
    // 清除标注图层
    if (this.map && this.annotationLayer) {
      this.map.removeLayer(this.annotationLayer);
      this.annotationLayer = null;
    }
    
    // 停止聚合类型信息窗口轮播
    this.stopClusterInfoCarousel();
    
    // 清除滚轮事件监听器
    if (this._wheelHandler && this.mapContainer) {
      if (this.mapContainer.removeEventListener) {
        this.mapContainer.removeEventListener('wheel', this._wheelHandler);
        this.mapContainer.removeEventListener('mousewheel', this._wheelHandler);
        this.mapContainer.removeEventListener('DOMMouseScroll', this._wheelHandler);
      } else if (this.mapContainer.detachEvent) {
        this.mapContainer.detachEvent('onmousewheel', this._wheelHandler);
      }
      this._wheelHandler = null;
    }
    
    // 销毁地图实例
    if (this.map) {
      this.map.destroy();
      this.map = null;
    }
    
    // 清空容器
    this.container.empty();
    
  }
});